#include "tgbotmgr.h"
#include "json.h"
#include "log.h"
#include <sstream>


TgBotMgr::TgBotMgr()
{
    tgBot_Map = {};
}
TgBotMgr::~TgBotMgr()
{

}

bool TgBotMgr::TgBotInfo_Init(const std::map<std::string, std::string>& bot_cfg)
{
    // 把配置加载到内存中
    for (const auto& t : bot_cfg)
    {
        const std::string& key = t.first;
        const std::string& value = t.second;// bots数组

        Json::Reader reader;
        Json::Value root;
        // std::istringstream botsStream(value);

        // 尝试解析 JSON 字符串
        if (!reader.parse(value.c_str(), root)) {

            log_error("Parse Config JSON Error, key: %s, Msg: %s;", key.c_str(), reader.getFormattedErrorMessages().c_str());
            return false;
        }

        if(!root["bots"].isArray())
        {
            log_error("Parse Config JSON Error, 'bots' not array, key: %s, value: %s;", key.c_str(), value.c_str());
            return false;
        }

        // 解析 bots 数组
        const Json::Value& bots = root["bots"];
        for(const auto& bot : bots)
        {
            BotInfo bot_info;
            bot_info.chat_ids.reserve(20); // 预估 一个bot 20个群组

            if(!bot.isMember("message_type") || !bot["message_type"].isString())
            {
                log_error("Parse 'message_type' Failed, not found or not string, key: %s, value: %s;", key.c_str(), value.c_str());
                return false;
            }

            if(!bot.isMember("bot_token") || !bot["bot_token"].isString())
            {
                log_error("Parse 'bot_token' Failed, not found or not string, key: %s, value: %s;", key.c_str(), value.c_str());
                return false;
            }

            if(!bot.isMember("send_limit") || !bot["send_limit"].isUInt())
            {
                log_error("Parse 'send_limit' Failed, not found or not uint, key: %s, value: %s;", key.c_str(), value.c_str());
                return false;
            }

            if(!bot.isMember("chat_ids") || !bot["chat_ids"].isArray())
            {
                log_error("Parse 'chat_ids' Failed, not found or not array, key: %s, value: %s;", key.c_str(), value.c_str());
                return false;
            }


            bot_info.message_type = bot["message_type"].asString();
            bot_info.tgBotToken = bot["bot_token"].asString();
            bot_info.send_limit = bot["send_limit"].asUInt();
            // 获取bot 对应群组信息
            for (const auto& chat_id : bot["chat_ids"]) {
                if(chat_id.isString()) {
                    bot_info.chat_ids.push_back(chat_id.asString());
                }
                else {
                    log_error("Parse 'chat_id' Error, chat_id not string");
                    return false;
                }
            }

            tgBot_Map[bot_info.message_type] = std::move(bot_info);
        }
    }
    log_debug("Load Config to tgBot_Map Success, tgBot_Map size: %zu;", tgBot_Map.size());

    // 输出 tgBot_Map 信息
    for(auto& x : tgBot_Map)
    {
        log_debug("key: %s, bot_token: %s;", x.first.c_str(), x.second.tgBotToken.c_str());
        log_debug("message_type: %s;", x.second.message_type.c_str());
        log_debug("send_limit: %u;", x.second.send_limit);
        log_debug("chat_ids size: %zu;", x.second.chat_ids.size());
        for(auto& chat_id : x.second.chat_ids)
        {
            log_debug("chat_id: %s;", chat_id.c_str());
        }
    }

    return true;
}



bool TgBotMgr::PushMessageQue(const std::string& msg_type, tgbot::TgBotNotifyMessageReq& msg)
{
    const auto& it = tgBot_Map.find(msg_type);
    if(it == tgBot_Map.end()) {
        log_error("botMsg_queue push error, not message type to bot, msg_type:%s;",msg_type.c_str());
        return false;
    }

    if(it->second.botMsg_queue.size() >= it->second.max_msgQue)
    {
        log_error("botMsg_queue push error, exceed message que length limit, botMsg_queue size:%zu, max_msgQue:%d;", it->second.botMsg_queue.size(), it->second.max_msgQue);
        it->second.dis_msg_count++;// 丢弃消息统计
        return false;
    }

    it->second.botMsg_queue.push(msg);
    log_debug("botMsg_queue push success, msg_text: %s;", msg.msg_text().c_str());
    return true;
}

std::map<std::string, BotInfo>& TgBotMgr::GetAllBots()
{
    return tgBot_Map;
}

void TgBotMgr::AddDiscardMsgCount(const std::string& msg_type)
{
    const auto& it = tgBot_Map.find(msg_type);
    if(it == tgBot_Map.end()) {
        it->second.dis_msg_count++;
    }
}